% --------------------------------- %
% Mauro Tardivo Filho - 063140		%
% --------------------------------- %
% ------------- TODO -------------- %
% - APDU: Detalhar mais
% - Listar tentativas mal sucedidas de compilar em Linux
% - possibilidade de alguém reiniciar a applet c/ outro PIN/PUK e usar o cartão (tlvz de um terceiro)
% p/ guardar suas chaves e certificado (mesmo cartão sendo de outra pessoa)
% - testes com cartão já inicializado e c/ perfil
% - testes c/ novo adobe
% - testes c/ brysigner
% - autenticação / logon PAM P11
% - aplicativo de assinatura e autenticação web

\documentclass[a4paper,10pt]{article}

\usepackage[brazil]{babel}
\usepackage[utf8]{inputenc}
\usepackage{fullpage}
\usepackage{graphicx}
\usepackage{amsmath}
\usepackage{titlesec}
\usepackage{stfloats}
\usepackage{color}
\usepackage{fixltx2e}
\usepackage{float}
\floatstyle{ruled}

\newcommand{\estrang}[1]{\emph{#1}}
\newcommand{\reserv}[1]{\begin{small}\texttt{#1}\end{small}}

\newcounter{bib}

\title{Compilação, Conversão e Instalação da applet CardEdge em um cartão de testes GemXpresso versão 4\\[-1.5cm]}
\author{Mauro Tardivo Filho}
\date{}

\begin{document}
\maketitle

\section{Conceitos Básicos}

\subsection{Formatos da Applet}

A applet pode ser gerada em três diferentes formatos: EXP (Export), JCA (Java Card Assembly), CAP (Converted Applet). Este último será o foco deste relatório visto que é o formato padrão para applets JavaCard. Além disso, há o formato IJC (Interoperable JavaCard), o qual pode ser convertido a partir do formato CAP, cujo procedimento será detalhado logo mais.

A extensão \reserv{.JCA} tem por objetivo auxiliar em testes e depuração, costumando gerar o arquivo de extensão \reserv{.JAR}.
O arquivo de formato EXP só pode ser gerado no momento da conversão e ele contém apenas informações das interfaces públicas de seu pacote, sendo útil para conversões de um outro pacote que utilizam classes daquele primeiro, porém não é usado diretamente pela JCVM.

O arquivo Java Card \reserv{CAP} é análogo ao formato Java \reserv{class}, com algumas diferenças como, por exemplo, um arquivo \reserv{CAP} contém uma representação de todas as classes de um pacote, enquanto um arquivo \reserv{class} contém apenas uma Java \reserv{class}.

A informação contida em um arquivo \reserv{CAP} é distribuída em um número de componentes individuais, onde cada componente contém informação sobre um aspecto das classes de um pacote Java. Por exemplo, o componente \reserv{Class} contém informação que define o conjunto de classes de um pacote Java, e o componente \reserv{Method} contém informação que define o conjunto dos métodos (byte codes) em um pacote e toda informação contidas nestes componentes são otimizadas para a plataforma de um cartão inteligente.

\refstepcounter{bib}\label{bib:jar}
Cada componente é armazenado em um arquivo separado, e todos estes são armazenados em um único arquivo JAR (Java Archive [\ref{bib:jar}]). Todos os componentes possuem a mesma 

\begin{itemize}
\item  \reserv{tag} (rótulo) – indentifica o tipo do componente
\item  \reserv{size} – indica o número de bytes que \reserv{info[]}
\item  \reserv{info[]} – contém os dados e seu formato é específico para cada tipo de componente
\end{itemize}

Os componentes podem ser: Applet, Class, ConstantPool, Descriptor, Directory, Header, Import, Method, RefLocation, StaticField.

\subsection{Conversão CAP para IJC}

O formato IJC é produzido por uma transformação do arquivo CAP, de forma a atender os requisitos do verificador no cartão (\estrang{on-card}), não sendo possível converter um arquivo Java \reserv{class} para um arquivo IJC, assim como não é possível converter um arquivo IJC para um arquivo CAP.

Para efetuar a conversão, deve-se descompactar o arquivo CAP, utilizando o comando \reserv{jar xvf <Arquivo CAP>} cujo resultado são arquivos CAP menores, como é mostrado a seguir:

\begin{verbatim}
jar xvf CardEdge.cap
extracted: com/musclecard/CardEdge/javacard/Header.cap
extracted: com/musclecard/CardEdge/javacard/Directory.cap
extracted: com/musclecard/CardEdge/javacard/Applet.cap
extracted: com/musclecard/CardEdge/javacard/Import.cap
extracted: com/musclecard/CardEdge/javacard/ConstantPool.cap
extracted: com/musclecard/CardEdge/javacard/Class.cap
extracted: com/musclecard/CardEdge/javacard/Method.cap
extracted: com/musclecard/CardEdge/javacard/StaticField.cap
extracted: com/musclecard/CardEdge/javacard/RefLocation.cap
extracted: com/musclecard/CardEdge/javacard/Descriptor.cap
\end{verbatim}

Para gerar o arquivo IJC deve-se concatenar os arquivos CAP como pode ser visto no comando abaixo e o hash do arquivo gerado:


\begin{verbatim}
cat com/musclecard/CardEdge/javacard/Header.cap \
com/musclecard/CardEdge/javacard/Directory.cap \
com/musclecard/CardEdge/javacard/Import.cap \
com/musclecard/CardEdge/javacard/Applet.cap \
com/musclecard/CardEdge/javacard/Class.cap \
com/musclecard/CardEdge/javacard/Method.cap \
com/musclecard/CardEdge/javacard/StaticField.cap \
com/musclecard/CardEdge/javacard/ConstantPool.cap \
com/musclecard/CardEdge/javacard/RefLocation.cap \
com/musclecard/CardEdge/javacard/Descriptor.cap > \
CardEdge.ijc

sha1sum CardEdge.ijc
3d43aefca6d5249ebb72d86842c48c55b9a95fb1  CardEdge.ijc
\end{verbatim}

A ordem dos arquivos está descrita na especificação da \estrang{Java Card Virtual Machine} (JCVM) [\ref{}], sendo definida esta ordem pela \estrang{Java Card Forum} e pela \estrang{Visa Open Platform} com objetivo de padronizar e aumentar a interoperabilidade. 
A \estrang{Open Platform} transferiu suas especificações para ser melhorada e padronizada pela \estrang{Global Platform}.

% http://java.sun.com/javacard/specs.htmlhttp://java.sun.com/javacard/specs.html
% https://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/ViewFilteredProducts-SimpleBundleDownload
% http://www.javacardforum.org/03_documents/00_documents/fileload_01.pdf

%Both the Java Card Forum and Visa Open Platform specification have adopted this component load order as a
%standard to enhance interoperability. In both cases the Descriptor Component is not loaded. Furthermore, the
%Visa Open Platform specification defines the format of packets (APDUs) used during installation.


\textbf{Observação:} Foi possível verificar que não é necessária que a extensão seja IJC para o arquivo de saída, pois consegue-se carregar arquivos com extensão qualquer. Este motivo deve-se ao fato do cartão verificar o código binário gerado.



\section{Configuração do ambiente de desenvolvimento no Windows}

\refstepcounter{bib}\label{bib:driverwin}

Inicialmente, deve ser realizada a instalação do driver da leitora de cartões GemPC Twin USB de acordo com está disponibilizado no site da Gemalto [\ref{bib:driverwin}]. Em seguida, configura-se o ambiente para compilação e instalação da applet no cartão inteligente utilizando os seguintes programas:

\begin{itemize}
\refstepcounter{bib}
	\label{bib:jdk}
	\item Java(TM) 2 SDK, Standard Edition 1.2.2\_017 for Windows (JDK) [\ref{bib:jdk}] 

\refstepcounter{bib}
	\label{bib:jcdk}
	\item Java Card(TM) Development Kit 2.1.2 (JCDK) [\ref{bib:jcdk}]

\refstepcounter{bib}
	\label{bib:gpshell}
	\item GPShell 1.4.2 [\ref{bib:gpshell}]
	
\end{itemize}

Os cartões inteligentes utilizados pela Unicamp e a applet são compatíveis com as versões indicadas anteriormente para JDK (1.2) e JCDK (2.1), 
caso contrário podem ocorrer erros na compilação, conversão ou instalação da applet.

\refstepcounter{bib} \label{bib:opensc}
\refstepcounter{bib} \label{bib:scb}
Para inicializar a estrutura PKCS \#15 do cartão inteligente, foram utilizadas as ferramentas do projeto OpenSC [\ref{bib:opensc}] para o Windows, também conhecidas por \estrang{Smart Card Bundle} [\ref{bib:scb}] e os comandos devem ser executados no diretório onde o \estrang{Smart Card Bundle} foi instalado.


\section{Compilação, conversão e ins\-talação da applet}

\refstepcounter{bib} \label{bib:applet}
A applet [\ref{bib:applet}] foi descompactada no diretório \reserv{C:$\backslash$} e, através do comando \reserv{javac} do kit de desenvolvimento Java (JDK), os arquivos \reserv{.class} correspondentes são gerados, como pode ser visto 
na Figura \ref{fig:compile}. 
O hash SHA-1 deste código-fonte é \reserv{e2bdb22939aac9db2082e8c40285491f5f4c5498}.

Eles localizam-se, a partir do diretório corrente, no dirétorio \reserv{src$\backslash$com$\backslash$musclecard$\backslash$CardEdge}, devido às classes estarem contidas no pacote \reserv{com.musclecard.CardEdge} e devido à flag ``-d '' .

%\reserv{C:$\backslash$jdk1.2.2$\backslash$bin$\backslash$javac -verbose -g -classpath ..$\backslash$java\_card\_kit-2\_1\_2$\backslash$lib$\backslash$api21.jar -d . src$\backslash$com$\backslash$musclecard$\backslash$CardEdge$\backslash$*.java}


% Compilação
\begin{figure}[H]
	\centering
		\includegraphics[width=0.85\textwidth]{./images/compile.png}
		\caption{Compilação da Applet no Windows}
	\label{fig:compile}
\end{figure}

Para gerar o arquivo \reserv{.CAP} (que é o formato padrão para carga no cartão), é usado o programa \reserv{converter.bat} do kit de desenvolvimento Java Card (JCDK), como pode ser visto 
na Figura \ref{fig:convert}. 
%no comando abaixo

%\reserv{..$\backslash$java\_card\_kit-2\_1\_2$\backslash$bin$\backslash$converter.bat -config CardEdge.opt}

% Conversão
\begin{figure}[H]
	\centering
		\includegraphics[width=0.85\textwidth]{./images/convert}
	\caption{Conversão da Applet para .CAP no Windows}
	\label{fig:convert}
\end{figure}

É utilizado um arquivo de configuração com extensão \reserv{.opt}, que contém as seguintes opções:

\begin{itemize}
	\item formato de arquivo a ser gerado (EXP, JCA, CAP)
	\item os caminhos a serem usados na árvore de diretórios pelo conversor
	\item o AID (application identifier) e a classe que define o método \reserv{install} para a applet
	\item o nome do pacote
	\item o PID (package identifier) e a versão, no formado \reserv{maior\_versão.menor\_versão}
\end{itemize}

Para a conversão da applet para a extensão \reserv{.CAP}, é utilizado o arquivo de configuração \reserv{CardEdge.opt}, cujo conteúdo é mostrado na Figura \ref{fig:opt}.

\begin{figure}[H]
\centering
\fbox{\includegraphics[width=0.6\textwidth]{images/cardedgeopt.png}}
\caption{Arquivo CardEdge.opt}
\label{fig:opt}%
\end{figure}

%\begin{verbatim}
%-out CAP
%-exportpath ..\java_card_kit-2_1_2\api21_export_files
%-applet 0xA0:00:00:00:01:01 CardEdge
%com.musclecard.CardEdge
%0xA0:00:00:00:01 1.0
%\end{verbatim}

O hash do arquivo CAP foi calculado através do comando abaixo:

% HASH CARDEDGE.CAP
\begin{verbatim}
sha1sum CardEdge.cap
b5fd677f6eac6fdb3b6d0007c3e292ce9b6ae1d3  CardEdge.cap
\end{verbatim}

Em nota, o hash do arquivo CAP pode apresentar diferenças pois depende dos parâmetros de compilação e/ou conversão, versão de compilador, método usado para compilação, entre outros fatores. Portanto, a verificação do hash do código-fonte [\ref{bib:applet}] é 
mais importante do que o binário em si.

\refstepcounter{bib}
	\label{bib:globalplat}
A instalação da applet no cartão inteligente Java Card de testes da Unicamp (GemXpresso R4) ocorre com a ajuda da ferramenta GPShell, da GlobalPlatform 
[\ref{bib:globalplat}], que traduz comandos de alto-nível em APDUs e comunica-se com o cartão de modo seguro.
A instalação da applet é executada através do comando \reserv{gpshell gxp4\_cardEdgecapInstall.txt}, sendo \reserv{gxp4\_cardEdgecapInstall.txt} o script mostrado na Figura \ref{fig:script}.

%Script 
\begin{figure}[ht]
\centering
\fbox{\includegraphics[width=0.9\textwidth]{images/script}}
\caption{Script para carregar a applet CardEdge.cap}%
\label{fig:script}%
\end{figure}

A instalação da applet pode ser efetuada com o comando \reserv{install} com os seguintes parâmetros: \\
\begin{center}
\reserv{install -file appletfile -priv privilege -sdAID zzz -AID AID\_in\_pkg -pkgAID package\_AID -instAID instance\_AID -nvCodeLimit yyy -nvDataLimit xxx}
\end{center}

Os parâmetros \reserv{-AID}, \reserv{-instAID} (Instance AID), \reserv{-pkgAID} (Package AID), \reserv{-nvCodeLimit} (Non-volatile Code size Limit) e \reserv{-nvDataLimit} (Non-volatile Data size Limit) podem ser detectados automaticamente. Para o \reserv{-sdAID} (Security Domain AID), o AID pode ser informado através do comando \reserv{select}, caso não seja passado por parâmetro. Se não for informado de nenhuma das duas formas, é escolhido um valor padrão, ou seja, normalmente não é necessário informar o valor do \reserv{-sdAID}.



\section{Configuração da estrutura PKCS\#15} \label{sec:cfgpkcs15}

\refstepcounter{bib} \label{bib:pkcs15}
	Para a configuração da estrutura PKCS\#15 [\ref{bib:pkcs15}] na applet CardEdge, são utilizados programas do projeto OpenSC [\ref{bib:opensc}] para enviar uma APDU ao cartão e para inicializar a estrutura PKCS\#15 da applet. APDU (Application Protocol Data Unit) é a unidade de comunicação entre o cartão e a leitora de cartões.
	
	Após a instalação da applet no cartão inteligente, é necessário configurar o PIN, a fim de que seja possível inicializá-lo em seguida. A configuração do PIN é realizada de um modo mais rudimentar (baixo-nível), enviando diretamente as APDUs ao cartão e configurado o PIN com um valor \reserv{00000000}, por exemplo, através do seguinte comando:

%\begin{minipage}{\columnwidth}
\begin{center}	
\reserv{
opensc-tool -s 00:A4:04:00:06:A0:00:00:00:01:01 -s 
B0:2A:00:00:38:08:4D:75:73:63:6C:65:30:30:04:01:08:30:30:30:30:30:30:30:30:08:30:30:30:30:30:3
0:30:30:05:02:08:30:30:30:30:30:30:30:30:08:30:30:30:30:30:30:30:30:00:00:17:70:00:02:01}
\end{center}
%\end{minipage}

A opção \reserv{-s} da ferramenta \reserv{opensc-tool} envia uma APDU para o cartão. A primeira APDU seleciona a applet CardEdge e a segunda configura o PIN padrão do cartão, que está sendo configurado para \reserv{00000000}, mas esse valor poderia ser diferente (contendo de 4 a 8 caracteres), desde que a sequência seja transformada para o código ASCII correspondente e enviada na forma de parâmetro do \reserv{opensc-tool}.


Nas Tabelas \ref{apduum} e \ref{apdudois} são visto byte-a-byte o significado da primeira e segunda APDU, respectivamente, do comando acima.

\begin{table}[h!]
\label{apduum}
\centering
\caption{Tabela dos bytes da primeira APDU}
\begin{tabular}{|c|p{8cm}|}
\hline
00 & CLA (class byte) \\ \hline
A4 & INS (instruction byte) \\ \hline
04 & Seleciona um DF pelo seu nome (tipo da instrução) \\ \hline
00 & Necessita de resposta (response byte) \\ \hline
06 & Especifica o tamanho dos dados  \\ \hline
A0:00:00:00:01:01 & Especifica o arquivo a ser selecionado pelo seu identificador ou nome, sendo pelo identificador neste caso \\ \hline
\end{tabular}
\end{table}

%\begin{verbatim}
\begin{table}[h!]
\label{apdudois}
\centering
\caption{Tabela dos bytes da segunda APDU}
\begin{tabular}{|c|p{8cm}|}
\hline
B0                      & CLA (class byte) \\ \hline
2A                      & INS\_WRITE\_FRAMEWORK (instruction byte) \\ \hline
00:00                   & Nada importante \\ \hline
38                      & Quantidade de dados a partir deste byte \\ \hline
08                      & Tamanho da chave de transporte \\ \hline
4D:75:73:63:6C:65:30:30 & chave de transporte existente ('Muscle00') \\ \hline
04                      & Número de tentativas para o PIN de administrador \\ \hline
01                      & Número de tentativas para o desbloqueio do PIN de administrador \\ \hline
08                      & Tamanho do PIN de administrador \\ \hline
30:30:30:30:30:30:30:30 & PIN de administrador '00000000' \\ \hline
08                      & Tamanho do PIN de desbloqueio para PIN de administrador \\ \hline
30:30:30:30:30:30:30:30 & PIN de desbloqueio para PIN de administrador '00000000' \\ \hline
05                      & Número de tentativas para o PIN de administrador \\ \hline
01                      & Número de tentativas para o desbloqueio do PIN de administrador \\ \hline
08                      & Tamanho do PIN de administrador \\ \hline
30:30:30:30:30:30:30:30 & PIN de usuário '00000000' \\ \hline
08                      & Tamanho do PIN de desbloqueio para PIN de usuário \\ \hline
30:30:30:30:30:30:30:30 & PIN de desbloqueio para PIN de usuário '00000000' \\ \hline
00:00:17:70             & Tamanho de armazenamento do objeto \\ \hline
00                      & ACLs - Qualquer um pode criar objetos \\ \hline
02                      & Utilização de chaves somente após a verificação do PIN de usuário \\ \hline
01                      & Utilização de PINs (de usuário) somente após a verificação do PIN de administrador \\ \hline
\end{tabular}
\end{table}

%\end{verbatim}

Para inicializar a estrutura PKCS\#15 e personalizar o cartão, utiliza-se outra ferramenta do projeto OpenSC, a \reserv{pkcs15-init}, como pode ser visto no exemplo a seguir: 

\begin{center}
	\reserv{pkcs15-init -C -p pkcs15+onepin}
\end{center}

A opção \reserv{-C} ou \reserv{--create-pkcs15} tem a função de criar uma nova estrutura PKCS\#15. Através deste comando é possível especificar o perfil a ser utilizado e opções relativas ao mesmo que modificam seu comportamento. Para isto, é utilizada a opção \reserv{--profile} ou \reserv{-p} seguida do nome do perfil e suas opções, sendo estes dois últimos separados pelo caractere \textbf{+}, como pôde ser visto anteriormente
O perfil é representado pela extensão \reserv{.profile} localizado em \reserv{/usr/share/opensc} no GNU/Linux e no diretório onde foi instalado o Smart Card Bundle no Windows.

Durante a criação desta estrutura, o usuário deverá entrar com algumas informações, conforme é mostrado a seguir: \\

\flushleft{
\reserv{
%\begin{verbatim}
New User PIN. \\
Please enter User PIN: \textcolor{blue}{00000000} \\
Please type again to verify: \textcolor{blue}{00000000} \\
Unblock Code for New User PIN (Optional - press return for no PIN). \\
Please enter User unblocking PIN (PUK): \textcolor{blue}{00000000} \\
Please type again to verify: \textcolor{blue}{00000000} \\
Unspecified PIN [reference 1] required. \\
Please enter Unspecified PIN [reference 1]: \textcolor{blue}{00000000} \\
%\end{verbatim}
}
}

\section{Testes com Cartões de Produção contendo a Estrutura da Unicamp}

\subsection{M.U.S.C.L.E.}

\refstepcounter{bib} \label{bib:cardedgeijc}
Foram testados 2 cartões, um contendo uma applet fornecida pelo projeto OpenSC [\ref{bib:cardedgeijc}] com nome \reserv{CardEdgeII.ijc} e número de série 30901, e outro com uma applet compilada conforme os passos descritos acima, utilizando o código-fonte [\ref{bib:applet}], com nome \reserv{CardEdge.cap} e número de série 30953. Para comparar estes arquivos, foi utilizado o comando 

\begin{center}\reserv{cmp <arquivo 1> <arquivo 2>}\end{center}

\noindent o qual compara byte a byte os dois arquivos, identificando o primeiro byte os quais diferem e obteve-se os seguintes resultados:

\begin{verbatim}
cmp CardEdge.cap CardEdge.ijc 
CardEdge.cap CardEdge.ijc difere: byte 1, linha 1
\end{verbatim}

\begin{verbatim}
cmp CardEdgeII.ijc CardEdge.ijc 
CardEdgeII.ijc CardEdge.ijc difere: byte 34, linha 2
\end{verbatim}

Pode-se notar que o arquivo IJC convertido do seu respectivo CAP diferiu logo no 1 byte da primeira linha. Enquanto isso, para o arquivo IJC fornecido pelo OpenSC já compilado diferiu no byte 34 da linha 2 com relação ao arquivo IJC convertido a partir do CAP gerado conforme os passos anteriores. Através de uma análise melhor (utilizando parâmetro \reserv{-l} no comando \reserv{cmp}, são mostrados todos os bytes que diferem) foi possível verificar que existem certas sequências de bytes que são diferentes, mas existem sequências grandes as quais não diferem, porém é inviável colocar a saída do comando neste relatório. Em nota, as diferenças podem ser decorrentes da conversão ou da compilação, efetuadas de forma diferente, ainda que possuissem o mesmo código-fonte.

\refstepcounter{bib} \label{bib:amanda}
Com auxílio da bibliografia principal [\ref{bib:amanda}], foram instalados os certificados das Autoridades Certificadoras e os módulos PKCS \# 11 no navegador web e no cliente de correio eletrônico.

Foram gerados os pares de chaves e instalados os certificados nos cartões 30901 e 30953, certificados testados assinando-se uma mensagem no cliente de correio eletrônico, como pode ser visto em um exemplo (Fig. \ref{fig:cert}).

\begin{figure}[H]
	\centering
		\includegraphics[width=0.75\textwidth]{./images/certificado.png}
		\caption{Certificado no M.U.S.C.L.E.}
	\label{fig:cert}
\end{figure}

Foi então gerado um certificado em software e importado para os cartões inteligentes, sendo então possível apenas assinar documentos e correios eletrônicos com o mesmo. Para excluir este certificado, o navegador web Mozilla Firefox e o cliente de correio eletrônico Mozilla Thunderbird apresentaram falhas. Apesar de não mostrarem mais o certificado após a exclusão, cada programa apresentou problemas em logar novamente com cada cartão. Retirando e inserindo o cartão o problema pareceu corrigido, mas através do comando \reserv{pkcs15-tool -D} foi possível verificar que o certificado e as chaves não foram removidos. 

Observação: Os testes que importam chaves para o cartão foram realizados de forma a enriquecer os testes, mas não é esperado que isto seja utilizado na prática.

\subsection{GemSAFE}

Juntamente com o M.U.S.C.L.E., os cartões inteligentes 30901 e 30953 possuem a applet de segurança da Gemalto, o GemSAFE. Foi instalado o módulo PKCS \# 11 (\reserv{gclib.dll}) para o navegador web e cliente de correio eletrônico, como pode ser visto na Fig. \ref{fig:gsmodule}, módulo este contido num pacote de ferramentas (GemSAFE Toolbox).

\begin{figure}[H]
	\centering
		\includegraphics[width=0.75\textwidth]{./imagesgemsafe/module.PNG}
		\caption{Módulo GemSAFE instalado}
	\label{fig:gsmodule}
\end{figure}

Inicialmente, o comportamente do applet foi insatisfatório, por não ser possível gerar chaves, nem importar certificados. Após uma atualização de firmware, o comportamento tornou-se satisfatório sendo possível gerar chaves e instalar certificados (Fig. \ref{fig:certgemsafe}), além de utilizar o certificado assinando mensagens por exemplo. A atualização de firmware só é necessária para cartões GemXpresso 4 fabricados até Março de 2010.

\begin{figure}[H]
	\centering
		\includegraphics[width=0.90\textwidth]{./imagesgemsafe/cert2.PNG}
		\caption{Certificado no GemSAFE}
	\label{fig:certgemsafe}
\end{figure}

Foi gerado um par de chaves e certifcado em software e este importado para os cartões inteligentes através do GemSAFE Toolbox, utilizando o botão \estrang{Import} da parte de certificados e escolhendo importar o certificado de um arquivo P12, que segue o padrão PKCS \# 12. Na Fig. \ref{fig:cert2gemsafe} pode-se ver os dois certificados instalados na applet GemSAFE.

\begin{figure}[H]
	\centering
		\includegraphics[width=0.90\textwidth]{./imagesgemsafe/cert2gemsafe.PNG}
		\caption{Dois certificados no GemSAFE }
	\label{fig:cert2gemsafe}
\end{figure}

Com os dois certificados foi possível assinar mensagens e a utilização desta applet não provocou interferência no funcionamento da applet M.U.S.C.L.E., ou seja, a applet M.U.S.C.L.E. permaneceu estável e sendo possível realizar operações de assinar mensagens, por exemplo.

\section{Riscos e Falhas de Segurança}

Sabe-se que não é possível exportar as chaves de um cartão inteligente, portanto, a autenticidade é garantida pela segurança do PIN. Porém, é possível reiniciar a estrutura PKCS \# 15 de um cartão através do comando \reserv{pkcs15-init} que foi mostrado na seção \ref{sec:cfgpkcs15}. 

Esta falha de segurança pode possibilitar alguém de tomar posse do cartão inteligente de um terceiro, alterar o PIN/PUK deste cartão, inserir chaves e certificado, e divulgar a chave pública e certificado como se fosse do terceiro, o que não é verdade.



\section{Conclusões}

Apesar de possuirem diferenças na comparação binária das applets CardEdge do sítio e da compilada através do código-fonte, notou-se que não houve diferenças de funcionamento entre os cartões 30901 e 30953. 
Tanto na utilização da applet do M.U.S.C.L.E. quanto na applet GemSAFE o resultado foi satisfatório e não houveram problemas de interferência entre as applets e os certificados contidos.


%- formatos da applet JCA EXP CAP IJC
%- conversao
%- muscle x gemsafe


\section{Bibliografia}

\noindent[\ref{bib:jar}] JAR - Java Archive: http://java.sun.com/docs/books/tutorial/deployment/jar/, último acesso: mar/2010

\noindent[\ref{bib:driverwin}] Software Components for the PC Twin, Gemalto, 
http://support.gemalto.com/?id=46, último acesso: dez/2009

\noindent[\ref{bib:jdk}] Java(TM) 2 SDK, Standard Edition 1.2.2\_017 para Windows, 
http://tiny.cc/RFz43, último acesso: dez/2009 %http://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/VerifyItem-Start/jdk-1_2_2_017-windows-i586.exe?BundledLineItemUUID=TEVIBe.op7YAAAEmDNATRCjA&OrderID=hGhIBe.owekAAAEm_M8TRCjA&ProductID=rsXACUFBdhYAAAEYk7Y5AXiy&FileName=/jdk-1_2_2_017-windows-i586.exe

\noindent[\ref{bib:jcdk}] Java Card(TM) Development Kit 2.1.2 para Windows,
http://tiny.cc/XHdNj, último acesso: dez/2009
%http://cds.sun.com/is-bin/INTERSHOP.enfinity/WFS/CDS-CDS_Developer-Site/en_US/-/USD/VerifyItem-Start/java_card_kit-2_1_2-win.zip?BundledLineItemUUID=WThIBe.o.7QAAAEm.z8TRCjK&OrderID=YbxIBe.o6SkAAAEm5D8TRCjK&ProductID=14bACUFBBAYAAAEYEKc5AXir&FileName=/java_card_kit-2_1_2-win.zip

\noindent[\ref{bib:gpshell}] GPShell 1.4.2 para Windows, 
http://tiny.cc/Wc4eF, último acesso: dez/2009
%http://sourceforge.net/projects/globalplatform/files/GPShell/GPShell-1.4.2/GPShell-1.4.2.zip/download

\noindent[\ref{bib:opensc}] OpenSC Project, http://www.opensc-project.org/, último acesso: dez/2009

\noindent[\ref{bib:scb}] Smart card bundle, http://www.opensc-project.org/scb/, último acesso: dez/2009

\noindent[\ref{bib:applet}] Código-Fonte da applet do projeto M.U.S.C.L.E. (CardEdge), http://tiny.cc/ZrLVL, último acesso: jan/2010
%https://alioth.debian.org/frs/download.php/465/MCardApplet-0.9.11.tar.gz
\\SHA-1: e2bdb22939aac9db2082e8c40285491f5f4c5498

\noindent[\ref{bib:globalplat}] Global Platform, http://www.globalplatform.org/, último acesso: dez/2009

\noindent[\ref{bib:pkcs15}] PKCS \#15: Cryptographic Token Information Format Standard, http://www.rsa.com/rsalabs/node.a\\sp?id=2141, último acesso: jan/2010

\noindent[\ref{bib:cardedgeijc}] http://www.opensc-project.org/opensc/raw-attachment/wiki/Cyberflex/CardEdgeII.ijc
\\SHA-1: 29e3f30e2788db6137aaf0cdb5d9bd0adfa5b235
\end{document}

%\noindent[\ref{bib:amanda}] AYRES, Amanda O. C.; \textit{Desenvolvimento de Ferramentas Baseadas em Software Livre para Integração de Cartões Inteligentes Java Card a uma Infra-Estrutura de Chaves Públicas}, 09/2008, Seminário Anual PIBIC,Vol. CD-ROM, pp.1-1, Campinas, SP, Brasil, 2008